#ifndef REncoding_H
#define REncoding_H

#include <System/RCore.h>
#include <System/Object.h>
#include <System/String.h>
#include <System/Array.h>
#include <System/ICloneable.h>

#include <Defines.h>
#include <CSharpPropertyMethods.h>

namespace Riccsson
{
	namespace System
	{
		namespace Text
		{
			// Not implemented yet.
			class Encoder;
			class Decoder;
			class EncoderFallback;
			class DecoderFallback;
			class EncodingInfo;
			class NormalizationForm;

			// Summary:
			//     Represents a character encoding.
			class Encoding
				: public Riccsson::System::ICloneable
			{
				
				static GC_PTR<Encoding> encoding_ASCII;
				static GC_PTR<Encoding> encoding_BigEndianUnicode;
				static GC_PTR<Encoding> encoding_Default;
				static GC_PTR<Encoding> encoding_Unicode;
				static GC_PTR<Encoding> encoding_UTF32;
				static GC_PTR<Encoding> encoding_UTF7;
				static GC_PTR<Encoding> encoding_utf8;

				PROP3_STATIC(Encoding, GC_PTR<Encoding>, ASCII)
				PROP3_STATIC(Encoding, GC_PTR<Encoding>, BigEndianUnicode)
				PROP3(Encoding, string, BodyName)
				PROP3(Encoding, int, CodePage)
				PROP3(Encoding, GC_PTR<DecoderFallback>, DecoderFallback_)
				PROP3_STATIC(Encoding, GC_PTR<Encoding>, Default)
				PROP3(Encoding, GC_PTR<EncoderFallback>, EncoderFallback_)
				PROP3(Encoding, string, EncodingName)
				PROP3(Encoding, string, HeaderName)
				PROP3(Encoding, bool, IsBrowserDisplay)
				PROP3(Encoding, bool, IsBrowserSave)
				PROP3(Encoding, bool, IsMailNewsDisplay)
				PROP3(Encoding, bool, IsMailNewsSave)
				PROP3(Encoding, bool, IsReadOnly)
				PROP3(Encoding, bool, IsSingleByte)
				PROP3_STATIC(Encoding, GC_PTR<Encoding>, Unicode)
				PROP3_STATIC(Encoding, GC_PTR<Encoding>, UTF32)
				PROP3_STATIC(Encoding, GC_PTR<Encoding>, UTF7)
				PROP3_STATIC(Encoding, GC_PTR<Encoding>, UTF8)
				PROP3(Encoding, string, WebName)
				PROP3(Encoding, int, WindowsCodePage)

				COPY_CONSTRUCTOR(Encoding)
				{
					PROP3_INIT_COPY(Encoding, string, BodyName);
					PROP3_INIT_COPY(Encoding, int, CodePage);
					PROP3_INIT_COPY(Encoding, GC_PTR<DecoderFallback>, DecoderFallback_);
					PROP3_INIT_COPY(Encoding, GC_PTR<EncoderFallback>, EncoderFallback_);
					PROP3_INIT_COPY(Encoding, string, EncodingName);
					PROP3_INIT_COPY(Encoding, string, HeaderName);
					PROP3_INIT_COPY(Encoding, bool, IsBrowserDisplay);
					PROP3_INIT_COPY(Encoding, bool, IsBrowserSave);
					PROP3_INIT_COPY(Encoding, bool, IsMailNewsDisplay);
					PROP3_INIT_COPY(Encoding, bool, IsMailNewsSave);
					PROP3_INIT_COPY(Encoding, bool, IsReadOnly);
					PROP3_INIT_COPY(Encoding, bool, IsSingleByte);
					PROP3_INIT_COPY(Encoding, string, WebName);
					PROP3_INIT_COPY(Encoding, int, WindowsCodePage);
				}

				// Summary:
				//     Initializes a new instance of the System.Text.Encoding class.
				protected: Encoding()
					: PROP3_INIT(Encoding, BodyName)
					, PROP3_INIT(Encoding, CodePage)
					, PROP3_INIT(Encoding, DecoderFallback_)
					, PROP3_INIT(Encoding, EncoderFallback_)
					, PROP3_INIT(Encoding, EncodingName)
					, PROP3_INIT(Encoding, HeaderName)
					, PROP3_INIT(Encoding, IsBrowserDisplay)
					, PROP3_INIT(Encoding, IsBrowserSave)
					, PROP3_INIT(Encoding, IsMailNewsDisplay)
					, PROP3_INIT(Encoding, IsMailNewsSave)
					, PROP3_INIT(Encoding, IsReadOnly)
					, PROP3_INIT(Encoding, IsSingleByte)
					, PROP3_INIT(Encoding, WebName)
					, PROP3_INIT(Encoding, WindowsCodePage)
				{
				}

				//
				// Summary:
				//     Initializes a new instance of the System.Text.Encoding class that corresponds
				//     to the specified code page.
				//
				// Parameters:
				//   codePage:
				//     The code page identifier of the preferred encoding.-or- 0, to use the default
				//     encoding.
				//
				// Exceptions:
				//   System.ArgumentOutOfRangeException:
				//     codePage is less than zero.
				protected: Encoding(int codePage)
					: PROP3_INIT(Encoding, BodyName)
					, PROP3_INIT(Encoding, CodePage)
					, PROP3_INIT(Encoding, DecoderFallback_)
					, PROP3_INIT(Encoding, EncoderFallback_)
					, PROP3_INIT(Encoding, EncodingName)
					, PROP3_INIT(Encoding, HeaderName)
					, PROP3_INIT(Encoding, IsBrowserDisplay)
					, PROP3_INIT(Encoding, IsBrowserSave)
					, PROP3_INIT(Encoding, IsMailNewsDisplay)
					, PROP3_INIT(Encoding, IsMailNewsSave)
					, PROP3_INIT(Encoding, IsReadOnly)
					, PROP3_INIT(Encoding, IsSingleByte)
					, PROP3_INIT(Encoding, WebName)
					, PROP3_INIT(Encoding, WindowsCodePage)
				{
				}

				// Summary:
				//     Gets an encoding for the ASCII (7-bit) character set.
				//
				// Returns:
				//     An encoding for the ASCII (7-bit) character set.
				//public: static Encoding ASCII { get; }
				protected: static PROP3_GET(GC_PTR<Encoding>, ASCII);
				private: static PROP3_SET(GC_PTR<Encoding>, ASCII){throw;}

				//
				// Summary:
				//     Gets an encoding for the UTF-16 format that uses the big endian byte order.
				//
				// Returns:
				//     An encoding object for the UTF-16 format that uses the big endian byte order.
				//public: static Encoding BigEndianUnicode { get; }
				public: static PROP3_GET(GC_PTR<Encoding>, BigEndianUnicode);
				private: static PROP3_SET(GC_PTR<Encoding>, BigEndianUnicode){throw;}

				//
				// Summary:
				//     When overridden in a derived class, gets a name for the current encoding
				//     that can be used with mail agent body tags.
				//
				// Returns:
				//     A name for the current System.Text.Encoding that can be used with mail agent
				//     body tags.-or- An empty string (""), if the current System.Text.Encoding
				//     cannot be used.
				//public: virtual string BodyName { get; }
				public: virtual PROP3_GET(string, BodyName)
				{
					throw;
				}
				private: PROP3_SET(string, BodyName){throw;}

				//
				// Summary:
				//     When overridden in a derived class, gets the code page identifier of the
				//     current System.Text.Encoding.
				//
				// Returns:
				//     The code page identifier of the current System.Text.Encoding.
				//public: virtual int CodePage { get; }
				public: virtual PROP3_GET(int, CodePage)
				{
					throw;
				}
				private: PROP3_SET(int, CodePage){throw;}

				//
				// Summary:
				//     Gets or sets the System.Text.DecoderFallback object for the current System.Text.Encoding
				//     object.
				//
				// Returns:
				//     The decoder fallback object for the current System.Text.Encoding object.
				//
				// Exceptions:
				//   System.ArgumentNullException:
				//     The value in a set operation is null.
				//
				//   System.InvalidOperationException:
				//     A value cannot be assigned in a set operation because the current System.Text.Encoding
				//     object is read-only.
				//[ComVisible(false)]
				//public: DecoderFallback DecoderFallback { get; set; }
				public: PROP3_GET(GC_PTR<DecoderFallback>, DecoderFallback_)
				{
					throw;
				}
				public: PROP3_SET(GC_PTR<DecoderFallback>, DecoderFallback_)
				{
					throw;
				}

				//
				// Summary:
				//     Gets an encoding for the operating system's current ANSI code page.
				//
				// Returns:
				//     An encoding for the operating system's current ANSI code page.
				//public: static Encoding Default { get; }
				public: static PROP3_GET(GC_PTR<Encoding>, Default);
				private: static PROP3_SET(GC_PTR<Encoding>, Default){throw;}

				//
				// Summary:
				//     Gets or sets the System.Text.EncoderFallback object for the current System.Text.Encoding
				//     object.
				//
				// Returns:
				//     The encoder fallback object for the current System.Text.Encoding object.
				//
				// Exceptions:
				//   System.ArgumentNullException:
				//     The value in a set operation is null.
				//
				//   System.InvalidOperationException:
				//     A value cannot be assigned in a set operation because the current System.Text.Encoding
				//     object is read-only.
				//[ComVisible(false)]
				//public: EncoderFallback EncoderFallback { get; set; }
				public: PROP3_GET(GC_PTR<EncoderFallback>, EncoderFallback_)
				{
					throw;
				}
				public: PROP3_SET(GC_PTR<EncoderFallback>, EncoderFallback_)
				{
					throw;
				}

				//
				// Summary:
				//     When overridden in a derived class, gets the human-readable description of
				//     the current encoding.
				//
				// Returns:
				//     The human-readable description of the current System.Text.Encoding.
				//public: virtual string EncodingName { get; }
				public: virtual PROP3_GET(string, EncodingName)
				{
					throw;
				}
				private: PROP3_SET(string, EncodingName){throw;}

				//
				// Summary:
				//     When overridden in a derived class, gets a name for the current encoding
				//     that can be used with mail agent header tags.
				//
				// Returns:
				//     A name for the current System.Text.Encoding to use with mail agent header
				//     tags.-or- An empty string (""), if the current System.Text.Encoding cannot
				//     be used.
				//public: virtual string HeaderName { get; }
				public: virtual PROP3_GET(string, HeaderName)
				{
					throw;
				}
				private: PROP3_SET(string, HeaderName){throw;}

				//
				// Summary:
				//     When overridden in a derived class, gets a value indicating whether the current
				//     encoding can be used by browser clients for displaying content.
				//
				// Returns:
				//     true if the current System.Text.Encoding can be used by browser clients for
				//     displaying content; otherwise, false.
				//public: virtual bool IsBrowserDisplay { get; }
				public: virtual PROP3_GET(bool, IsBrowserDisplay)
				{
					throw;
				}
				private: PROP3_SET(bool, IsBrowserDisplay){throw;}

				//
				// Summary:
				//     When overridden in a derived class, gets a value indicating whether the current
				//     encoding can be used by browser clients for saving content.
				//
				// Returns:
				//     true if the current System.Text.Encoding can be used by browser clients for
				//     saving content; otherwise, false.
				//public: virtual bool IsBrowserSave { get; }
				public: virtual PROP3_GET(bool, IsBrowserSave)
				{
					throw;
				}
				private: PROP3_SET(bool, IsBrowserSave){throw;}

				//
				// Summary:
				//     When overridden in a derived class, gets a value indicating whether the current
				//     encoding can be used by mail and news clients for displaying content.
				//
				// Returns:
				//     true if the current System.Text.Encoding can be used by mail and news clients
				//     for displaying content; otherwise, false.
				//public: virtual bool IsMailNewsDisplay { get; }
				public: virtual PROP3_GET(bool, IsMailNewsDisplay)
				{
					throw;
				}
				private: PROP3_SET(bool, IsMailNewsDisplay){throw;}

				//
				// Summary:
				//     When overridden in a derived class, gets a value indicating whether the current
				//     encoding can be used by mail and news clients for saving content.
				//
				// Returns:
				//     true if the current System.Text.Encoding can be used by mail and news clients
				//     for saving content; otherwise, false.
				//public: virtual bool IsMailNewsSave { get; }
				public: virtual PROP3_GET(bool, IsMailNewsSave)
				{
					throw;
				}
				private: PROP3_SET(bool, IsMailNewsSave){throw;}

				//
				// Summary:
				//     When overridden in a derived class, gets a value indicating whether the current
				//     encoding is read-only.
				//
				// Returns:
				//     true if the current System.Text.Encoding is read-only; otherwise, false.
				//     The default is true.
				//[ComVisible(false)]
				//public: bool IsReadOnly { get; }
				public: PROP3_GET(bool, IsReadOnly)
				{
					throw;
				}
				private: PROP3_SET(bool, IsReadOnly){throw;}

				//
				// Summary:
				//     When overridden in a derived class, gets a value indicating whether the current
				//     encoding uses single-byte code points.
				//
				// Returns:
				//     true if the current System.Text.Encoding uses single-byte code points; otherwise,
				//     false.
				//[ComVisible(false)]
				//public: virtual bool IsSingleByte { get; }
				public: virtual PROP3_GET(bool, IsSingleByte)
				{
					throw;
				}
				private: PROP3_SET(bool, IsSingleByte){throw;}

				//
				// Summary:
				//     Gets an encoding for the UTF-16 format using the little endian byte order.
				//
				// Returns:
				//     An encoding for the UTF-16 format using the little endian byte order.
				//public: static Encoding Unicode { get; }
				public: static PROP3_GET(GC_PTR<Encoding>, Unicode);
				private: static PROP3_SET(GC_PTR<Encoding>, Unicode){throw;}

				//
				// Summary:
				//     Gets an encoding for the UTF-32 format using the little endian byte order.
				//
				// Returns:
				//     An encoding object for the UTF-32 format using the little endian byte order.
				//public: static Encoding UTF32 { get; }
				public: static PROP3_GET(GC_PTR<Encoding>, UTF32);
				private: static PROP3_SET(GC_PTR<Encoding>, UTF32){throw;}

				//
				// Summary:
				//     Gets an encoding for the UTF-7 format.
				//
				// Returns:
				//     An encoding for the UTF-7 format.
				//public: static Encoding UTF7 { get; }
				public: static PROP3_GET(GC_PTR<Encoding>, UTF7);
				private: static PROP3_SET(GC_PTR<Encoding>, UTF7){throw;}

				//
				// Summary:
				//     Gets an encoding for the UTF-8 format.
				//
				// Returns:
				//     An encoding for the UTF-8 format.
				//public: static Encoding UTF8 { get; }
				public: static PROP3_GET(GC_PTR<Encoding>, UTF8);
				private: static PROP3_SET(GC_PTR<Encoding>, UTF8){throw;}

				//
				// Summary:
				//     When overridden in a derived class, gets the name registered with the Internet
				//     Assigned Numbers Authority (IANA) for the current encoding.
				//
				// Returns:
				//     The IANA name for the current System.Text.Encoding.
				//public: virtual string WebName { get; }
				public: virtual PROP3_GET(string, WebName)
				{
					throw;
				}
				private: PROP3_SET(string, WebName){throw;}

				//
				// Summary:
				//     When overridden in a derived class, gets the Windows operating system code
				//     page that most closely corresponds to the current encoding.
				//
				// Returns:
				//     The Windows operating system code page that most closely corresponds to the
				//     current System.Text.Encoding.
				//public: virtual int WindowsCodePage { get; }
				public: virtual PROP3_GET(int, WindowsCodePage)
				{
					throw;
				}
				private: PROP3_SET(int, WindowsCodePage){throw;}


				// Summary:
				//     When overridden in a derived class, creates a shallow copy of the current
				//     System.Text.Encoding object.
				//
				// Returns:
				//     A copy of the current System.Text.Encoding object.
				//[ComVisible(false)]
				public: virtual GC_PTR<Object> Clone()
				{
					throw;
				}

				//
				// Summary:
				//     Converts an entire byte array from one encoding to another.
				//
				// Parameters:
				//   srcEncoding:
				//     The encoding format of bytes.
				//
				//   dstEncoding:
				//     The target encoding format.
				//
				//   bytes:
				//     The bytes to convert.
				//
				// Returns:
				//     An array of type System.Byte containing the results of converting bytes from
				//     srcEncoding to dstEncoding.
				//
				// Exceptions:
				//   System.ArgumentNullException:
				//     srcEncoding is null.-or- dstEncoding is null.-or- bytes is null.
				//
				//   System.Text.DecoderFallbackException:
				//     A fallback occurred (see Character Encoding in the .NET Framework for complete
				//     explanation)-and-srcEncoding.System.Text.Encoding.DecoderFallback is set
				//     to System.Text.DecoderExceptionFallback.
				//
				//   System.Text.EncoderFallbackException:
				//     A fallback occurred (see Character Encoding in the .NET Framework for complete
				//     explanation)-and-dstEncoding.System.Text.Encoding.EncoderFallback is set
				//     to System.Text.EncoderExceptionFallback.
				public: static GC_PTR<Riccsson::System::Array<byte>> Convert(Encoding* srcEncoding, Encoding* dstEncoding, Riccsson::System::Array<byte>* bytes)
				{
					throw;
				}

				//
				// Summary:
				//     Converts a range of bytes in a byte array from one encoding to another.
				//
				// Parameters:
				//   srcEncoding:
				//     The encoding of the source array, bytes.
				//
				//   dstEncoding:
				//     The encoding of the output array.
				//
				//   bytes:
				//     The array of bytes to convert.
				//
				//   index:
				//     The index of the first element of bytes to convert.
				//
				//   count:
				//     The number of bytes to convert.
				//
				// Returns:
				//     An array of type System.Byte containing the result of converting a range
				//     of bytes in bytes from srcEncoding to dstEncoding.
				//
				// Exceptions:
				//   System.ArgumentNullException:
				//     srcEncoding is null.-or- dstEncoding is null.-or- bytes is null.
				//
				//   System.ArgumentOutOfRangeException:
				//     index and count do not specify a valid range in the byte array.
				//
				//   System.Text.DecoderFallbackException:
				//     A fallback occurred (see Character Encoding in the .NET Framework for complete
				//     explanation)-and-srcEncoding.System.Text.Encoding.DecoderFallback is set
				//     to System.Text.DecoderExceptionFallback.
				//
				//   System.Text.EncoderFallbackException:
				//     A fallback occurred (see Character Encoding in the .NET Framework for complete
				//     explanation)-and-dstEncoding.System.Text.Encoding.EncoderFallback is set
				//     to System.Text.EncoderExceptionFallback.
				public: static GC_PTR<Riccsson::System::Array<byte>> Convert(Encoding* srcEncoding, Encoding* dstEncoding, Riccsson::System::Array<byte>* bytes, int index, int count);
				//
				// Summary:
				//     Determines whether the specified System.Object is equal to the current instance.
				//
				// Parameters:
				//   value:
				//     The System.Object to compare with the current instance.
				//
				// Returns:
				//     true if value is an instance of System.Text.Encoding and is equal to the
				//     current instance; otherwise, false.
				public: override bool Equals(object value)
				{
					throw;
				}

				//
				// Summary:
				//     When overridden in a derived class, calculates the number of bytes produced
				//     by encoding all the characters in the specified character array.
				//
				// Parameters:
				//   chars:
				//     The character array containing the characters to encode.
				//
				// Returns:
				//     The number of bytes produced by encoding all the characters in the specified
				//     character array.
				//
				// Exceptions:
				//   System.ArgumentNullException:
				//     chars is null.
				//
				//   System.Text.EncoderFallbackException:
				//     A fallback occurred (see Character Encoding in the .NET Framework for complete
				//     explanation)-and-System.Text.Encoding.EncoderFallback is set to System.Text.EncoderExceptionFallback.
				public: virtual int GetByteCount(Riccsson::System::Array<char>* chars)
				{
					throw;
				}
				//
				// Summary:
				//     When overridden in a derived class, calculates the number of bytes produced
				//     by encoding the characters in the specified string.
				//
				// Parameters:
				//   s:
				//     The string containing the set of characters to encode.
				//
				// Returns:
				//     The number of bytes produced by encoding the specified characters.
				//
				// Exceptions:
				//   System.ArgumentNullException:
				//     s is null.
				//
				//   System.Text.EncoderFallbackException:
				//     A fallback occurred (see Character Encoding in the .NET Framework for complete
				//     explanation)-and-System.Text.Encoding.EncoderFallback is set to System.Text.EncoderExceptionFallback.
				public: virtual int GetByteCount(string* s)
				{
					throw;
				}
				//
				// Summary:
				//     When overridden in a derived class, calculates the number of bytes produced
				//     by encoding a set of characters starting at the specified character pointer.
				//
				// Parameters:
				//   chars:
				//     A pointer to the first character to encode.
				//
				//   count:
				//     The number of characters to encode.
				//
				// Returns:
				//     The number of bytes produced by encoding the specified characters.
				//
				// Exceptions:
				//   System.ArgumentNullException:
				//     chars is null.
				//
				//   System.ArgumentOutOfRangeException:
				//     count is less than zero.
				//
				//   System.Text.EncoderFallbackException:
				//     A fallback occurred (see Character Encoding in the .NET Framework for complete
				//     explanation)-and-System.Text.Encoding.EncoderFallback is set to System.Text.EncoderExceptionFallback.
				//[CLSCompliant(false)]
				//[ComVisible(false)]
				//[SecurityCritical]
				public: virtual int GetByteCount(Riccsson::System::Array<char>* chars, int count)
				{
					throw;
				}

				//
				// Summary:
				//     When overridden in a derived class, calculates the number of bytes produced
				//     by encoding a set of characters from the specified character array.
				//
				// Parameters:
				//   chars:
				//     The character array containing the set of characters to encode.
				//
				//   index:
				//     The index of the first character to encode.
				//
				//   count:
				//     The number of characters to encode.
				//
				// Returns:
				//     The number of bytes produced by encoding the specified characters.
				//
				// Exceptions:
				//   System.ArgumentNullException:
				//     chars is null.
				//
				//   System.ArgumentOutOfRangeException:
				//     index or count is less than zero.-or- index and count do not denote a valid
				//     range in chars.
				//
				//   System.Text.EncoderFallbackException:
				//     A fallback occurred (see Character Encoding in the .NET Framework for complete
				//     explanation)-and-System.Text.Encoding.EncoderFallback is set to System.Text.EncoderExceptionFallback.
				public: virtual int GetByteCount(Riccsson::System::Array<char>* chars, int index, int count) = 0;
				//
				// Summary:
				//     When overridden in a derived class, encodes all the characters in the specified
				//     character array into a sequence of bytes.
				//
				// Parameters:
				//   chars:
				//     The character array containing the characters to encode.
				//
				// Returns:
				//     A byte array containing the results of encoding the specified set of characters.
				//
				// Exceptions:
				//   System.ArgumentNullException:
				//     chars is null.
				//
				//   System.Text.EncoderFallbackException:
				//     A fallback occurred (see Character Encoding in the .NET Framework for complete
				//     explanation)-and-System.Text.Encoding.EncoderFallback is set to System.Text.EncoderExceptionFallback.
				public: virtual GC_PTR<Riccsson::System::Array<byte>> GetBytes(const Riccsson::System::Array<char>* chars)
				{
					throw;
				}

				//
				// Summary:
				//     When overridden in a derived class, encodes all the characters in the specified
				//     string into a sequence of bytes.
				//
				// Parameters:
				//   s:
				//     The string containing the characters to encode.
				//
				// Returns:
				//     A byte array containing the results of encoding the specified set of characters.
				//
				// Exceptions:
				//   System.ArgumentNullException:
				//     s is null.
				//
				//   System.Text.EncoderFallbackException:
				//     A fallback occurred (see Character Encoding in the .NET Framework for complete
				//     explanation)-and-System.Text.Encoding.EncoderFallback is set to System.Text.EncoderExceptionFallback.
				public: virtual GC_PTR<Riccsson::System::Array<byte>> GetBytes(const string* s)
				{
					throw;
				}

				//
				// Summary:
				//     When overridden in a derived class, encodes a set of characters from the
				//     specified character array into a sequence of bytes.
				//
				// Parameters:
				//   chars:
				//     The character array containing the set of characters to encode.
				//
				//   index:
				//     The index of the first character to encode.
				//
				//   count:
				//     The number of characters to encode.
				//
				// Returns:
				//     A byte array containing the results of encoding the specified set of characters.
				//
				// Exceptions:
				//   System.ArgumentNullException:
				//     chars is null.
				//
				//   System.ArgumentOutOfRangeException:
				//     index or count is less than zero.-or- index and count do not denote a valid
				//     range in chars.
				//
				//   System.Text.EncoderFallbackException:
				//     A fallback occurred (see Character Encoding in the .NET Framework for complete
				//     explanation)-and-System.Text.Encoding.EncoderFallback is set to System.Text.EncoderExceptionFallback.
				//[TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
				public: virtual GC_PTR<Riccsson::System::Array<byte>> GetBytes(Riccsson::System::Array<char>* chars, int index, int count)
				{
					throw;
				}

				//
				// Summary:
				//     When overridden in a derived class, encodes a set of characters starting
				//     at the specified character pointer into a sequence of bytes that are stored
				//     starting at the specified byte pointer.
				//
				// Parameters:
				//   chars:
				//     A pointer to the first character to encode.
				//
				//   charCount:
				//     The number of characters to encode.
				//
				//   bytes:
				//     A pointer to the location at which to start writing the resulting sequence
				//     of bytes.
				//
				//   byteCount:
				//     The maximum number of bytes to write.
				//
				// Returns:
				//     The actual number of bytes written at the location indicated by the bytes
				//     parameter.
				//
				// Exceptions:
				//   System.ArgumentNullException:
				//     chars is null.-or- bytes is null.
				//
				//   System.ArgumentOutOfRangeException:
				//     charCount or byteCount is less than zero.
				//
				//   System.ArgumentException:
				//     byteCount is less than the resulting number of bytes.
				//
				//   System.Text.EncoderFallbackException:
				//     A fallback occurred (see Character Encoding in the .NET Framework for complete
				//     explanation)-and-System.Text.Encoding.EncoderFallback is set to System.Text.EncoderExceptionFallback.
				//[CLSCompliant(false)]
				//[ComVisible(false)]
				//[SecurityCritical]
				public: virtual int GetBytes(Riccsson::System::Array<char>* chars, int charCount, Riccsson::System::Array<byte>* bytes, int byteCount)
				{
					throw;
				}

				//
				// Summary:
				//     When overridden in a derived class, encodes a set of characters from the
				//     specified character array into the specified byte array.
				//
				// Parameters:
				//   chars:
				//     The character array containing the set of characters to encode.
				//
				//   charIndex:
				//     The index of the first character to encode.
				//
				//   charCount:
				//     The number of characters to encode.
				//
				//   bytes:
				//     The byte array to contain the resulting sequence of bytes.
				//
				//   byteIndex:
				//     The index at which to start writing the resulting sequence of bytes.
				//
				// Returns:
				//     The actual number of bytes written into bytes.
				//
				// Exceptions:
				//   System.ArgumentNullException:
				//     chars is null.-or- bytes is null.
				//
				//   System.ArgumentOutOfRangeException:
				//     charIndex or charCount or byteIndex is less than zero.-or- charIndex and
				//     charCount do not denote a valid range in chars.-or- byteIndex is not a valid
				//     index in bytes.
				//
				//   System.ArgumentException:
				//     bytes does not have enough capacity from byteIndex to the end of the array
				//     to accommodate the resulting bytes.
				//
				//   System.Text.EncoderFallbackException:
				//     A fallback occurred (see Character Encoding in the .NET Framework for complete
				//     explanation)-and-System.Text.Encoding.EncoderFallback is set to System.Text.EncoderExceptionFallback.
				public: virtual int GetBytes(Riccsson::System::Array<char>* chars, int charIndex, int charCount, Riccsson::System::Array<byte>* bytes, int byteIndex) = 0;
				//
				// Summary:
				//     When overridden in a derived class, encodes a set of characters from the
				//     specified string into the specified byte array.
				//
				// Parameters:
				//   s:
				//     The string containing the set of characters to encode.
				//
				//   charIndex:
				//     The index of the first character to encode.
				//
				//   charCount:
				//     The number of characters to encode.
				//
				//   bytes:
				//     The byte array to contain the resulting sequence of bytes.
				//
				//   byteIndex:
				//     The index at which to start writing the resulting sequence of bytes.
				//
				// Returns:
				//     The actual number of bytes written into bytes.
				//
				// Exceptions:
				//   System.ArgumentNullException:
				//     s is null.-or- bytes is null.
				//
				//   System.ArgumentOutOfRangeException:
				//     charIndex or charCount or byteIndex is less than zero.-or- charIndex and
				//     charCount do not denote a valid range in chars.-or- byteIndex is not a valid
				//     index in bytes.
				//
				//   System.ArgumentException:
				//     bytes does not have enough capacity from byteIndex to the end of the array
				//     to accommodate the resulting bytes.
				//
				//   System.Text.EncoderFallbackException:
				//     A fallback occurred (see Character Encoding in the .NET Framework for complete
				//     explanation)-and-System.Text.Encoding.EncoderFallback is set to System.Text.EncoderExceptionFallback.
				public: virtual int GetBytes(string* s, int charIndex, int charCount, Riccsson::System::Array<byte>* bytes, int byteIndex)
				{
					throw;
				}

				//
				// Summary:
				//     When overridden in a derived class, calculates the number of characters produced
				//     by decoding all the bytes in the specified byte array.
				//
				// Parameters:
				//   bytes:
				//     The byte array containing the sequence of bytes to decode.
				//
				// Returns:
				//     The number of characters produced by decoding the specified sequence of bytes.
				//
				// Exceptions:
				//   System.ArgumentNullException:
				//     bytes is null.
				//
				//   System.Text.DecoderFallbackException:
				//     A fallback occurred (see Character Encoding in the .NET Framework for complete
				//     explanation)-and-System.Text.Encoding.DecoderFallback is set to System.Text.DecoderExceptionFallback.
				public: virtual int GetCharCount(Riccsson::System::Array<byte>* bytes)
				{
					throw;
				}

				//
				// Summary:
				//     When overridden in a derived class, calculates the number of characters produced
				//     by decoding a sequence of bytes starting at the specified byte pointer.
				//
				// Parameters:
				//   bytes:
				//     A pointer to the first byte to decode.
				//
				//   count:
				//     The number of bytes to decode.
				//
				// Returns:
				//     The number of characters produced by decoding the specified sequence of bytes.
				//
				// Exceptions:
				//   System.ArgumentNullException:
				//     bytes is null.
				//
				//   System.ArgumentOutOfRangeException:
				//     count is less than zero.
				//
				//   System.Text.DecoderFallbackException:
				//     A fallback occurred (see Character Encoding in the .NET Framework for complete
				//     explanation)-and-System.Text.Encoding.DecoderFallback is set to System.Text.DecoderExceptionFallback.
				//[CLSCompliant(false)]
				//[ComVisible(false)]
				//[SecurityCritical]
				public: virtual int GetCharCount(Riccsson::System::Array<byte>* bytes, int count)
				{
					throw;
				}

				//
				// Summary:
				//     When overridden in a derived class, calculates the number of characters produced
				//     by decoding a sequence of bytes from the specified byte array.
				//
				// Parameters:
				//   bytes:
				//     The byte array containing the sequence of bytes to decode.
				//
				//   index:
				//     The index of the first byte to decode.
				//
				//   count:
				//     The number of bytes to decode.
				//
				// Returns:
				//     The number of characters produced by decoding the specified sequence of bytes.
				//
				// Exceptions:
				//   System.ArgumentNullException:
				//     bytes is null.
				//
				//   System.ArgumentOutOfRangeException:
				//     index or count is less than zero.-or- index and count do not denote a valid
				//     range in bytes.
				//
				//   System.Text.DecoderFallbackException:
				//     A fallback occurred (see Character Encoding in the .NET Framework for complete
				//     explanation)-and-System.Text.Encoding.DecoderFallback is set to System.Text.DecoderExceptionFallback.
				public: virtual int GetCharCount(Riccsson::System::Array<byte>* bytes, int index, int count) = 0;
				//
				// Summary:
				//     When overridden in a derived class, decodes all the bytes in the specified
				//     byte array into a set of characters.
				//
				// Parameters:
				//   bytes:
				//     The byte array containing the sequence of bytes to decode.
				//
				// Returns:
				//     A character array containing the results of decoding the specified sequence
				//     of bytes.
				//
				// Exceptions:
				//   System.ArgumentNullException:
				//     bytes is null.
				//
				//   System.Text.DecoderFallbackException:
				//     A fallback occurred (see Character Encoding in the .NET Framework for complete
				//     explanation)-and-System.Text.Encoding.DecoderFallback is set to System.Text.DecoderExceptionFallback.
				public: virtual GC_PTR<Riccsson::System::Array<char>> GetChars(Riccsson::System::Array<byte>* bytes)
				{
					throw;
				}

				//
				// Summary:
				//     When overridden in a derived class, decodes a sequence of bytes from the
				//     specified byte array into a set of characters.
				//
				// Parameters:
				//   bytes:
				//     The byte array containing the sequence of bytes to decode.
				//
				//   index:
				//     The index of the first byte to decode.
				//
				//   count:
				//     The number of bytes to decode.
				//
				// Returns:
				//     A character array containing the results of decoding the specified sequence
				//     of bytes.
				//
				// Exceptions:
				//   System.ArgumentNullException:
				//     bytes is null.
				//
				//   System.ArgumentOutOfRangeException:
				//     index or count is less than zero.-or- index and count do not denote a valid
				//     range in bytes.
				//
				//   System.Text.DecoderFallbackException:
				//     A fallback occurred (see Character Encoding in the .NET Framework for complete
				//     explanation)-and-System.Text.Encoding.DecoderFallback is set to System.Text.DecoderExceptionFallback.
				public: virtual GC_PTR<Riccsson::System::Array<char>> GetChars(Riccsson::System::Array<byte>* bytes, int index, int count)
				{
					throw;
				}

				//
				// Summary:
				//     When overridden in a derived class, decodes a sequence of bytes starting
				//     at the specified byte pointer into a set of characters that are stored starting
				//     at the specified character pointer.
				//
				// Parameters:
				//   bytes:
				//     A pointer to the first byte to decode.
				//
				//   byteCount:
				//     The number of bytes to decode.
				//
				//   chars:
				//     A pointer to the location at which to start writing the resulting set of
				//     characters.
				//
				//   charCount:
				//     The maximum number of characters to write.
				//
				// Returns:
				//     The actual number of characters written at the location indicated by the
				//     chars parameter.
				//
				// Exceptions:
				//   System.ArgumentNullException:
				//     bytes is null.-or- chars is null.
				//
				//   System.ArgumentOutOfRangeException:
				//     byteCount or charCount is less than zero.
				//
				//   System.ArgumentException:
				//     charCount is less than the resulting number of characters.
				//
				//   System.Text.DecoderFallbackException:
				//     A fallback occurred (see Character Encoding in the .NET Framework for complete
				//     explanation)-and-System.Text.Encoding.DecoderFallback is set to System.Text.DecoderExceptionFallback.
				//[CLSCompliant(false)]
				//[ComVisible(false)]
				//[SecurityCritical]
				public: virtual int GetChars(Riccsson::System::Array<byte>* bytes, int byteCount, Riccsson::System::Array<char>* chars, int charCount)
				{
					throw;
				}

				//
				// Summary:
				//     When overridden in a derived class, decodes a sequence of bytes from the
				//     specified byte array into the specified character array.
				//
				// Parameters:
				//   bytes:
				//     The byte array containing the sequence of bytes to decode.
				//
				//   byteIndex:
				//     The index of the first byte to decode.
				//
				//   byteCount:
				//     The number of bytes to decode.
				//
				//   chars:
				//     The character array to contain the resulting set of characters.
				//
				//   charIndex:
				//     The index at which to start writing the resulting set of characters.
				//
				// Returns:
				//     The actual number of characters written into chars.
				//
				// Exceptions:
				//   System.ArgumentNullException:
				//     bytes is null.-or- chars is null.
				//
				//   System.ArgumentOutOfRangeException:
				//     byteIndex or byteCount or charIndex is less than zero.-or- byteindex and
				//     byteCount do not denote a valid range in bytes.-or- charIndex is not a valid
				//     index in chars.
				//
				//   System.ArgumentException:
				//     chars does not have enough capacity from charIndex to the end of the array
				//     to accommodate the resulting characters.
				//
				//   System.Text.DecoderFallbackException:
				//     A fallback occurred (see Character Encoding in the .NET Framework for complete
				//     explanation)-and-System.Text.Encoding.DecoderFallback is set to System.Text.DecoderExceptionFallback.
				public: virtual int GetChars(Riccsson::System::Array<byte>* bytes, int byteIndex, int byteCount, Riccsson::System::Array<char>* chars, int charIndex) = 0;
				//
				// Summary:
				//     When overridden in a derived class, obtains a decoder that converts an encoded
				//     sequence of bytes into a sequence of characters.
				//
				// Returns:
				//     A System.Text.Decoder that converts an encoded sequence of bytes into a sequence
				//     of characters.
				public: virtual GC_PTR<Decoder> GetDecoder()
				{
					throw;
				}

				//
				// Summary:
				//     When overridden in a derived class, obtains an encoder that converts a sequence
				//     of Unicode characters into an encoded sequence of bytes.
				//
				// Returns:
				//     A System.Text.Encoder that converts a sequence of Unicode characters into
				//     an encoded sequence of bytes.
				public: virtual GC_PTR<Encoder> GetEncoder()
				{
					throw;
				}

				//
				// Summary:
				//     Returns the encoding associated with the specified code page identifier.
				//
				// Parameters:
				//   codepage:
				//     The code page identifier of the preferred encoding. Possible values are listed
				//     in the Code Page column of the table that appears in the System.Text.Encoding
				//     class topic.-or- 0 (zero), to use the default encoding.
				//
				// Returns:
				//     The encoding that is associated with the specified code page.
				//
				// Exceptions:
				//   System.ArgumentOutOfRangeException:
				//     codepage is less than zero or greater than 65535.
				//
				//   System.ArgumentException:
				//     codepage is not supported by the underlying platform.
				//
				//   System.NotSupportedException:
				//     codepage is not supported by the underlying platform.
				//[SecuritySafeCritical]
				public: static GC_PTR<Encoding> GetEncoding(int codepage)
				{
					throw;
				}

				//
				// Summary:
				//     Returns the encoding associated with the specified code page name.
				//
				// Parameters:
				//   name:
				//     The code page name of the preferred encoding. Any value returned by the System.Text.Encoding.WebName
				//     property is valid. Possible values are listed in the Name column of the table
				//     that appears in the System.Text.Encoding class topic.
				//
				// Returns:
				//     The encoding associated with the specified code page.
				//
				// Exceptions:
				//   System.ArgumentException:
				//     name is not a valid code page name.-or- The code page indicated by name is
				//     not supported by the underlying platform.
				public: static GC_PTR<Encoding> GetEncoding(string* name)
				{
					throw;
				}

				//
				// Summary:
				//     Returns the encoding associated with the specified code page identifier.
				//     Parameters specify an error handler for characters that cannot be encoded
				//     and byte sequences that cannot be decoded.
				//
				// Parameters:
				//   codepage:
				//     The code page identifier of the preferred encoding. Possible values are listed
				//     in the Code Page column of the table that appears in the System.Text.Encoding
				//     class topic.-or- 0 (zero), to use the default encoding.
				//
				//   encoderFallback:
				//     An object that provides an error-handling procedure when a character cannot
				//     be encoded with the current encoding.
				//
				//   decoderFallback:
				//     An object that provides an error-handling procedure when a byte sequence
				//     cannot be decoded with the current encoding.
				//
				// Returns:
				//     The encoding that is associated with the specified code page.
				//
				// Exceptions:
				//   System.ArgumentOutOfRangeException:
				//     codepage is less than zero or greater than 65535.
				//
				//   System.ArgumentException:
				//     codepage is not supported by the underlying platform.
				//
				//   System.NotSupportedException:
				//     codepage is not supported by the underlying platform.
				public: static GC_PTR<Encoding> GetEncoding(int codepage, EncoderFallback* encoderFallback, DecoderFallback* decoderFallback)
				{
					throw;
				}

				//
				// Summary:
				//     Returns the encoding associated with the specified code page name. Parameters
				//     specify an error handler for characters that cannot be encoded and byte sequences
				//     that cannot be decoded.
				//
				// Parameters:
				//   name:
				//     The code page name of the preferred encoding. Any value returned by the System.Text.Encoding.WebName
				//     property is valid. Possible values are listed in the Name column of the table
				//     that appears in the System.Text.Encoding class topic.
				//
				//   encoderFallback:
				//     An object that provides an error-handling procedure when a character cannot
				//     be encoded with the current encoding.
				//
				//   decoderFallback:
				//     An object that provides an error-handling procedure when a byte sequence
				//     cannot be decoded with the current encoding.
				//
				// Returns:
				//     The encoding that is associated with the specified code page.
				//
				// Exceptions:
				//   System.ArgumentException:
				//     name is not a valid code page name.-or- The code page indicated by name is
				//     not supported by the underlying platform.
				public: static GC_PTR<Encoding> GetEncoding(string name, EncoderFallback* encoderFallback, DecoderFallback* decoderFallback)
				{
					throw;
				}

				//
				// Summary:
				//     Returns an array that contains all encodings.
				//
				// Returns:
				//     An array that contains all encodings.
				public: static GC_PTR<Riccsson::System::Array<EncodingInfo>> GetEncodings()
				{
					throw;
				}

				//
				// Summary:
				//     Returns the hash code for the current instance.
				//
				// Returns:
				//     The hash code for the current instance.
				public: override int GetHashCode()
				{
					throw;
				}

				//
				// Summary:
				//     When overridden in a derived class, calculates the maximum number of bytes
				//     produced by encoding the specified number of characters.
				//
				// Parameters:
				//   charCount:
				//     The number of characters to encode.
				//
				// Returns:
				//     The maximum number of bytes produced by encoding the specified number of
				//     characters.
				//
				// Exceptions:
				//   System.ArgumentOutOfRangeException:
				//     charCount is less than zero.
				//
				//   System.Text.EncoderFallbackException:
				//     A fallback occurred (see Character Encoding in the .NET Framework for complete
				//     explanation)-and-System.Text.Encoding.EncoderFallback is set to System.Text.EncoderExceptionFallback.
				public: virtual int GetMaxByteCount(int charCount) = 0;
				//
				// Summary:
				//     When overridden in a derived class, calculates the maximum number of characters
				//     produced by decoding the specified number of bytes.
				//
				// Parameters:
				//   byteCount:
				//     The number of bytes to decode.
				//
				// Returns:
				//     The maximum number of characters produced by decoding the specified number
				//     of bytes.
				//
				// Exceptions:
				//   System.ArgumentOutOfRangeException:
				//     byteCount is less than zero.
				//
				//   System.Text.DecoderFallbackException:
				//     A fallback occurred (see Character Encoding in the .NET Framework for complete
				//     explanation)-and-System.Text.Encoding.DecoderFallback is set to System.Text.DecoderExceptionFallback.
				public: virtual int GetMaxCharCount(int byteCount) = 0;
				//
				// Summary:
				//     When overridden in a derived class, returns a sequence of bytes that specifies
				//     the encoding used.
				//
				// Returns:
				//     A byte array containing a sequence of bytes that specifies the encoding used.-or-
				//     A byte array of length zero, if a preamble is not required.
				public: virtual GC_PTR<Riccsson::System::Array<byte>> GetPreamble()
				{
					throw;
				}

				//
				// Summary:
				//     When overridden in a derived class, decodes all the bytes in the specified
				//     byte array into a string.
				//
				// Parameters:
				//   bytes:
				//     The byte array containing the sequence of bytes to decode.
				//
				// Returns:
				//     A string that contains the results of decoding the specified sequence of
				//     bytes.
				//
				// Exceptions:
				//   System.ArgumentException:
				//     The byte array contains invalid Unicode code points.
				//
				//   System.ArgumentNullException:
				//     bytes is null.
				//
				//   System.Text.DecoderFallbackException:
				//     A fallback occurred (see Character Encoding in the .NET Framework for complete
				//     explanation)-and-System.Text.Encoding.DecoderFallback is set to System.Text.DecoderExceptionFallback.
				public: virtual GC_PTR<Riccsson::System::string> GetString(Riccsson::System::Array<byte>* bytes)
				{
					return GC_PTR<Riccsson::System::string>( new Riccsson::System::string( (const byte*)bytes->get(), (int)0, (int)bytes->Length ) );
				}

				//
				// Summary:
				//     When overridden in a derived class, decodes a sequence of bytes from the
				//     specified byte array into a string.
				//
				// Parameters:
				//   bytes:
				//     The byte array containing the sequence of bytes to decode.
				//
				//   index:
				//     The index of the first byte to decode.
				//
				//   count:
				//     The number of bytes to decode.
				//
				// Returns:
				//     A string that contains the results of decoding the specified sequence of
				//     bytes.
				//
				// Exceptions:
				//   System.ArgumentException:
				//     The byte array contains invalid Unicode code points.
				//
				//   System.ArgumentNullException:
				//     bytes is null.
				//
				//   System.ArgumentOutOfRangeException:
				//     index or count is less than zero.-or- index and count do not denote a valid
				//     range in bytes.
				//
				//   System.Text.DecoderFallbackException:
				//     A fallback occurred (see Character Encoding in the .NET Framework for complete
				//     explanation)-and-System.Text.Encoding.DecoderFallback is set to System.Text.DecoderExceptionFallback.
				public: virtual GC_PTR<Riccsson::System::string> GetString(Riccsson::System::Array<byte>* bytes, int index, int count)
				{
					return GC_PTR<Riccsson::System::string>( new string( bytes->get(), index, count ) );
				}

				//
				// Summary:
				//     Gets a value indicating whether the current encoding is always normalized,
				//     using the default normalization form.
				//
				// Returns:
				//     true if the current System.Text.Encoding is always normalized; otherwise,
				//     false. The default is false.
				//[ComVisible(false)]
				public: bool IsAlwaysNormalized()
				{
					throw;
				}

				//
				// Summary:
				//     When overridden in a derived class, gets a value indicating whether the current
				//     encoding is always normalized, using the specified normalization form.
				//
				// Parameters:
				//   form:
				//     One of the System.Text.NormalizationForm values.
				//
				// Returns:
				//     true if the current System.Text.Encoding object is always normalized using
				//     the specified System.Text.NormalizationForm value; otherwise, false. The
				//     default is false.
				//[ComVisible(false)]
				public: virtual bool IsAlwaysNormalized(NormalizationForm* form)
				{
					throw;
				}

			};

		}
	}
}
#endif //EXTENSIONS_H